Skunkware 5/Skunkware 5.iso/src/Tools/freeWAIS-sf-1.1/configure

Text File | 1995-01-10 | 82.6 KB | 3,059 lines

#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 1.10
# Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.

# This configure script is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This script is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

# Save the original args to write them into config.status later.
configure_args="$*"

# Only options that might do something get documented.
ac_usage="Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
--build=BUILD        configure for building on BUILD [BUILD=HOST]
--disable-FEATURE    do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG]    include FEATURE [ARG=yes]
--exec-prefix=PREFIX    install host dependent files in PREFIX [/usr/local]
--help            print this message
--host=HOST        configure for HOST [guessed]
--prefix=PREFIX        install host independent files in PREFIX [/usr/local]
--quiet, --silent    do not print \`checking for...' messages
--srcdir=DIR        find the sources in DIR [configure dir or ..]
--target=TARGET        configure for TARGET [TARGET=HOST]
--verbose        print results of checks
--version        print the version of autoconf that created configure
--with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
--without-PACKAGE    do not use PACKAGE (same as --with-PACKAGE=no)
--x-includes=DIR    X include files are in DIR
--x-libraries=DIR    X library files are in DIR"

# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
exec_prefix=
host=NONE
no_create=
nonopt=NONE
norecursion=
prefix=
program_prefix=
program_suffix=
program_transform_name=
silent=
srcdir=
target=NONE
verbose=
x_includes=
x_libraries=

ac_prev=
for ac_option
do

  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval "$ac_prev=\$ac_option"
    ac_prev=
    continue
  fi

  # Accept (but ignore some of) the important Cygnus configure
  # options, so we can diagnose typos.

  case "$ac_option" in
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  *) ac_optarg= ;;
  esac

  case "$ac_option" in

  -build | --build | --buil | --bui | --bu | --b)
    ac_prev=build ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*)
    build="$ac_optarg" ;;

  -disable-* | --disable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
    # Reject names that aren't valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
      echo "configure: $ac_feature: invalid feature name" >&2; exit 1
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    eval "enable_${ac_feature}=no" ;;

  -enable-* | --enable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
    # Reject names that aren't valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
      echo "configure: $ac_feature: invalid feature name" >&2; exit 1
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "enable_${ac_feature}='$ac_optarg'" ;;

  # For backward compatibility, recognize -exec-prefix and --exec_prefix.
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix="$ac_optarg" ;;

  -gas | --gas | --ga | --g)
    with_gas=yes ;; # Obsolete; use --with-gas.

  -help | --help | --hel | --he)
    cat << EOF
$ac_usage
EOF
    exit 0 ;;

  -host | --host | --hos | --ho)
    ac_prev=host ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host="$ac_optarg" ;;

  -nfp | --nfp | --nf)
    with_fp=no ;; # Obsolete; use --without-fp.

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c)
    no_create=yes ;;

  -norecursion | --norecursion | --norecursio | --norecursi \
  | --norecurs | --norecur | --norecu | --norec | --nore | --nor)
    norecursion=yes ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix="$ac_optarg" ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix="$ac_optarg" ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix="$ac_optarg" ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name="$ac_optarg" ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir="$ac_optarg" ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target="$ac_optarg" ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers)
    echo "configure generated by autoconf version 1.10"
    exit 0 ;;

  -with-* | --with-*)
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
    # Reject names that aren't valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
      echo "configure: $ac_package: invalid package name" >&2; exit 1
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "with_${ac_package}='$ac_optarg'" ;;

  -without-* | --without-*)
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
    # Reject names that aren't valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
      echo "configure: $ac_package: invalid package name" >&2; exit 1
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    eval "with_${ac_package}=no" ;;

  --x) with_x=yes ;; # Obsolete; use --with-x.

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes="$ac_optarg" ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries="$ac_optarg" ;;

  -*) echo "configure: $ac_option: invalid option; use --help to show usage" >&2; exit 1
    ;;

  *)
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
      echo "configure: warning: $ac_option: invalid host type" >&2
    fi
    if test "x$nonopt" != xNONE; then
      echo "configure: can only configure for one host and one target at a time" >&2; exit 1
    fi
    nonopt="$ac_option"
    ;;

  esac
done

if test -n "$ac_prev"; then
  echo "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" >&2; exit 1
fi

trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 2 15
trap 'rm -fr confdefs* $ac_clean_files' 0

# Save the original args if we used an alternate arg parser.
ac_configure_temp="${configure_args-$*}"
# Strip out --no-create and --norecursion so they don't pile up.
configure_args=
for ac_arg in $ac_configure_temp; do
  case "$ac_arg" in
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c) ;;
  -norecursion | --norecursion | --norecursio | --norecursi \
  | --norecurs | --norecur | --norecu | --norec | --nore | --nor) ;;
  *) configure_args="$configure_args $ac_arg" ;;
  esac
done

# NLS nuisances.
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
if test "${LC_ALL+set}" = 'set'; then LC_ALL=C; export LC_ALL; fi
if test "${LANG+set}"   = 'set'; then LANG=C;   export LANG;   fi

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
ac_unique_file=README

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then `..'.
  ac_prog=$0
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
  srcdir=$ac_confdir
  if test ! -r $srcdir/$ac_unique_file; then
    srcdir=..
  fi
fi
if test ! -r $srcdir/$ac_unique_file; then
  if test x$ac_srcdir_defaulted = xyes; then
    echo "configure: can not find sources in ${ac_confdir} or .." >&2; exit 1
  else
    echo "configure: can not find sources in ${srcdir}" >&2; exit 1
  fi
fi
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='${CPP}'
ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1'



#!/bin/sh
# From configure.in ITI Header __Header


FREE_WAIS_SF_VERSION="1.1"


{
test -n "$verbose" && \
echo "    defining" FREE_WAIS_SF_VERSION to be "$FREE_WAIS_SF_VERSION"
echo "#define" FREE_WAIS_SF_VERSION "$FREE_WAIS_SF_VERSION" >> confdefs.h
DEFS="$DEFS -DFREE_WAIS_SF_VERSION=$FREE_WAIS_SF_VERSION"
ac_sed_defs="${ac_sed_defs}\${ac_dA}FREE_WAIS_SF_VERSION\${ac_dB}FREE_WAIS_SF_VERSION\${ac_dC}$FREE_WAIS_SF_VERSION\${ac_dD}
\${ac_uA}FREE_WAIS_SF_VERSION\${ac_uB}FREE_WAIS_SF_VERSION\${ac_uC}$FREE_WAIS_SF_VERSION\${ac_uD}
\${ac_eA}FREE_WAIS_SF_VERSION\${ac_eB}FREE_WAIS_SF_VERSION\${ac_eC}$FREE_WAIS_SF_VERSION\${ac_eD}
"
}

DISTNAME="freeWAIS-sf"


{
test -n "$verbose" && \
echo "    defining" _DISTNAME_ to be "$DISTNAME"
echo "#define" _DISTNAME_ "$DISTNAME" >> confdefs.h
DEFS="$DEFS -D_DISTNAME_=$DISTNAME"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_DISTNAME_\${ac_dB}_DISTNAME_\${ac_dC}$DISTNAME\${ac_dD}
\${ac_uA}_DISTNAME_\${ac_uB}_DISTNAME_\${ac_uC}$DISTNAME\${ac_uD}
\${ac_eA}_DISTNAME_\${ac_eB}_DISTNAME_\${ac_eC}$DISTNAME\${ac_eD}
"
}


FREE_WAIS_SF_VERSION_STRING="$DISTNAME Release $FREE_WAIS_SF_VERSION"

{
test -n "$verbose" && \
echo "    defining" FREE_WAIS_SF_VERSION_STRING to be "\"$FREE_WAIS_SF_VERSION_STRING\""
echo "#define" FREE_WAIS_SF_VERSION_STRING "\"$FREE_WAIS_SF_VERSION_STRING\"" >> confdefs.h
DEFS="$DEFS -DFREE_WAIS_SF_VERSION_STRING=\"$FREE_WAIS_SF_VERSION_STRING\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}FREE_WAIS_SF_VERSION_STRING\${ac_dB}FREE_WAIS_SF_VERSION_STRING\${ac_dC}\"$FREE_WAIS_SF_VERSION_STRING\"\${ac_dD}
\${ac_uA}FREE_WAIS_SF_VERSION_STRING\${ac_uB}FREE_WAIS_SF_VERSION_STRING\${ac_uC}\"$FREE_WAIS_SF_VERSION_STRING\"\${ac_uD}
\${ac_eA}FREE_WAIS_SF_VERSION_STRING\${ac_eB}FREE_WAIS_SF_VERSION_STRING\${ac_eC}\"$FREE_WAIS_SF_VERSION_STRING\"\${ac_eD}
"
}


echo
echo You are about to build $FREE_WAIS_SF_VERSION_STRING
echo "This is *NOT* freeWAIS from CNIDR."
echo

CFLAGS='-g'

if test -z "$prefix"
then
  test -n "$silent" || echo "checking for waisserver to derive installation directory prefix"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="$IFS:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test $ac_dir != . && test -f $ac_dir/waisserver; then
      # Not all systems have dirname.
      prefix=`echo $ac_dir|sed 's%/[^/][^/]*$%%'`
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -n "$verbose" && echo "    chose installation directory prefix ${prefix}"
fi

if test -z "$CC"; then
  # Extract the first word of `gcc', so it can be a program name with args.
  set ac_dummy gcc; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      CC="gcc"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$CC" && CC="cc"
test -n "$CC" && test -n "$verbose" && echo "    setting CC to $CC"

# Find out if we are using GNU C, under whatever name.
cat > conftest.c <<EOF
#ifdef __GNUC__
  yes
#endif
EOF
${CC-cc} -E conftest.c > conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
  GCC=1 # For later tests.
fi
rm -f conftest*

test -n "$silent" || echo "checking how to run the C preprocessor"
if test -z "$CPP"; then
  # This must be in double quotes, not single quotes, because CPP may get
  # substituted into the Makefile and ``${CC-cc}'' will simply confuse
  # make.  It must be expanded now.
  CPP="${CC-cc} -E"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  :
else
  rm -rf conftest*
  CPP="${CC-cc} -E -traditional-cpp"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  :
else
  rm -rf conftest*
  CPP=/lib/cpp
fi
rm -f conftest*
fi
rm -f conftest*
fi
test -n "$verbose" && echo "    setting CPP to $CPP"

if test -z "$PCPP"; then
  # Extract the first word of `cpp', so it can be a program name with args.
  set ac_dummy cpp; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      PCPP="$dir/$word"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$PCPP" && PCPP="PCPP=$CPP"
test -n "$PCPP" && test -n "$verbose" && echo "    setting PCPP to $PCPP"

SAVE_PATH=$PATH
PATH="${PATH} /lib /usr/lib"
if test -z "$PCPP"; then
  # Extract the first word of `cpp', so it can be a program name with args.
  set ac_dummy cpp; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      PCPP=""
      break
    fi
  done
  IFS="$ac_save_ifs"
fi

test -n "$PCPP" && test -n "$verbose" && echo "    setting PCPP to $PCPP"

PATH=$SAVE_PATH
test -n "$silent" || echo "checking for HPUX"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#ifdef hpux || __hpux
  yes
#endif

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining _HPUX_SOURCE"
echo "#define" _HPUX_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_HPUX_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_HPUX_SOURCE\${ac_dB}_HPUX_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_HPUX_SOURCE\${ac_uB}_HPUX_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_HPUX_SOURCE\${ac_eB}_HPUX_SOURCE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


test -n "$silent" || echo "checking for minix/config.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <minix/config.h>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  rm -rf conftest*
  MINIX=1

fi
rm -f conftest*

# The Minix shell can't assign to the same variable on the same line!
if test -n "$MINIX"; then

{
test -n "$verbose" && \
echo "    defining _POSIX_SOURCE"
echo "#define" _POSIX_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD}
"
}


{
test -n "$verbose" && \
echo "    defining" _POSIX_1_SOURCE to be "2"
echo "#define" _POSIX_1_SOURCE "2" >> confdefs.h
DEFS="$DEFS -D_POSIX_1_SOURCE=2"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_1_SOURCE\${ac_dB}_POSIX_1_SOURCE\${ac_dC}2\${ac_dD}
\${ac_uA}_POSIX_1_SOURCE\${ac_uB}_POSIX_1_SOURCE\${ac_uC}2\${ac_uD}
\${ac_eA}_POSIX_1_SOURCE\${ac_eB}_POSIX_1_SOURCE\${ac_eC}2\${ac_eD}
"
}


{
test -n "$verbose" && \
echo "    defining _MINIX"
echo "#define" _MINIX "1" >> confdefs.h
DEFS="$DEFS -D_MINIX=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_MINIX\${ac_dB}_MINIX\${ac_dC}1\${ac_dD}
\${ac_uA}_MINIX\${ac_uB}_MINIX\${ac_uC}1\${ac_uD}
\${ac_eA}_MINIX\${ac_eB}_MINIX\${ac_eC}1\${ac_eD}
"
}

fi

test -n "$silent" || echo "checking for POSIXized ISC"
if test -d /etc/conf/kconfig.d &&
  grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
then
  ISC=1 # If later tests want to check for ISC.

{
test -n "$verbose" && \
echo "    defining _POSIX_SOURCE"
echo "#define" _POSIX_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD}
"
}

  if test -n "$GCC"; then
    CC="$CC -posix"
  else
    CC="$CC -Xp"
  fi
fi

test -n "$silent" || echo "checking for AIX"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#ifdef _AIX
  yes
#endif

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining _ALL_SOURCE"
echo "#define" _ALL_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_ALL_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_ALL_SOURCE\${ac_dB}_ALL_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_ALL_SOURCE\${ac_uB}_ALL_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_ALL_SOURCE\${ac_eB}_ALL_SOURCE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


if test "$CC" = "gcc" ; then
   AIX=`echo "$DEFS" | grep '_ALL_SOURCE'`;
   if test "$AIX" != "" ; then
        echo "INFO: will use cc on AIX"
        CC=cc
   fi
fi
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lseq"
ac_have_lib=""
test -n "$silent" || echo "checking for -lseq"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lseq"
else
   :;
fi


ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lsun"
ac_have_lib=""
test -n "$silent" || echo "checking for -lsun"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lsun"
else
   :;
fi


ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lintl"
ac_have_lib=""
test -n "$silent" || echo "checking for -lintl"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lintl"
else
   :;
fi


test -n "$silent" || echo "checking for directory library header"
ac_dir_header=
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for dirent.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <dirent.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining DIRENT"
echo "#define" DIRENT "1" >> confdefs.h
DEFS="$DEFS -DDIRENT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}DIRENT\${ac_dB}DIRENT\${ac_dC}1\${ac_dD}
\${ac_uA}DIRENT\${ac_uB}DIRENT\${ac_uC}1\${ac_uD}
\${ac_eA}DIRENT\${ac_eB}DIRENT\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=dirent.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for sys/ndir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/ndir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining SYSNDIR"
echo "#define" SYSNDIR "1" >> confdefs.h
DEFS="$DEFS -DSYSNDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSNDIR\${ac_dB}SYSNDIR\${ac_dC}1\${ac_dD}
\${ac_uA}SYSNDIR\${ac_uB}SYSNDIR\${ac_uC}1\${ac_uD}
\${ac_eA}SYSNDIR\${ac_eB}SYSNDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=sys/ndir.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for sys/dir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/dir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining SYSDIR"
echo "#define" SYSDIR "1" >> confdefs.h
DEFS="$DEFS -DSYSDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSDIR\${ac_dB}SYSDIR\${ac_dC}1\${ac_dD}
\${ac_uA}SYSDIR\${ac_uB}SYSDIR\${ac_uC}1\${ac_uD}
\${ac_eA}SYSDIR\${ac_eB}SYSDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=sys/dir.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for ndir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <ndir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining NDIR"
echo "#define" NDIR "1" >> confdefs.h
DEFS="$DEFS -DNDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NDIR\${ac_dB}NDIR\${ac_dC}1\${ac_dD}
\${ac_uA}NDIR\${ac_uB}NDIR\${ac_uC}1\${ac_uD}
\${ac_eA}NDIR\${ac_eB}NDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=ndir.h

fi
rm -f conftest*
fi

test -n "$silent" || echo "checking for closedir return value"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <$ac_dir_header>
int closedir(); main() { exit(closedir(opendir(".")) != 0); }
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else

{
test -n "$verbose" && \
echo "    defining VOID_CLOSEDIR"
echo "#define" VOID_CLOSEDIR "1" >> confdefs.h
DEFS="$DEFS -DVOID_CLOSEDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}VOID_CLOSEDIR\${ac_dB}VOID_CLOSEDIR\${ac_dC}1\${ac_dD}
\${ac_uA}VOID_CLOSEDIR\${ac_uB}VOID_CLOSEDIR\${ac_uC}1\${ac_uD}
\${ac_eA}VOID_CLOSEDIR\${ac_eB}VOID_CLOSEDIR\${ac_eC}1\${ac_eD}
"
}

fi
rm -fr conftest*

test -n "$silent" || echo "checking for Xenix"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#if defined(M_XENIX) && !defined(M_UNIX)
  yes
#endif

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  XENIX=1

fi
rm -f conftest*

if test -n "$XENIX"; then
  LIBS="$LIBS -lx"
  case "$DEFS" in
  *SYSNDIR*) ;;
  *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx.
  esac
fi

COMPILER_VERSION=`$CC -v 2>&1 | sed -e '1 d'`
if test "$COMPILER_VERSION" = "" ; then
   COMPILER_VERSION=$CC
fi

{
test -n "$verbose" && \
echo "    defining" COMPILER_VERSION to be "\"$COMPILER_VERSION\""
echo "#define" COMPILER_VERSION "\"$COMPILER_VERSION\"" >> confdefs.h
DEFS="$DEFS -DCOMPILER_VERSION=\"$COMPILER_VERSION\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}COMPILER_VERSION\${ac_dB}COMPILER_VERSION\${ac_dC}\"$COMPILER_VERSION\"\${ac_dD}
\${ac_uA}COMPILER_VERSION\${ac_uB}COMPILER_VERSION\${ac_uC}\"$COMPILER_VERSION\"\${ac_uD}
\${ac_eA}COMPILER_VERSION\${ac_eB}COMPILER_VERSION\${ac_eC}\"$COMPILER_VERSION\"\${ac_eD}
"
}

if test -n "$GCC"; then
  test -n "$silent" || echo "checking whether -traditional is needed"
  ac_pattern="Autoconf.*'x'"
  ac_prog='#include <sgtty.h>
Autoconf TIOCGETP'
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_prog
EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  ac_need_trad=1

fi
rm -f conftest*


  if test -z "$ac_need_trad"; then
    ac_prog='#include <termio.h>
Autoconf TCGETA'
    cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_prog
EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  ac_need_trad=1

fi
rm -f conftest*

  fi
  test -n "$ac_need_trad" && CC="$CC -traditional"
fi

if test -z "$RANLIB"; then
  # Extract the first word of `ranlib', so it can be a program name with args.
  set ac_dummy ranlib; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      RANLIB="ranlib"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$RANLIB" && RANLIB=":"
test -n "$RANLIB" && test -n "$verbose" && echo "    setting RANLIB to $RANLIB"

if test "$srcdir" = "." ; then
    srcdir=`pwd`;
fi
# Make sure to not get the incompatible SysV /etc/install and
# /usr/sbin/install, which might be in PATH before a BSD-like install,
# or the SunOS /usr/etc/install directory, or the AIX /bin/install,
# or the AFS install, which mishandles nonexistent args, or
# /usr/ucb/install on SVR4, which tries to use the nonexistent group
# `staff', or /sbin/install on IRIX which has incompatible command-line
# syntax.  Sigh.
#
#     On most BSDish systems install is in /usr/bin, not /usr/ucb
#     anyway.
# This turns out not to be true, so the mere pathname isn't an indication
# of whether the program works.  What we really need is a set of tests for
# the install program to see if it actually works in all the required ways.
#
# Avoid using ./install, which might have been erroneously created
# by make from ./install.sh.
if test -z "${INSTALL}"; then
  test -n "$silent" || echo "checking for a BSD compatible install"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    case "$ac_dir" in
    ''|.|/etc|/sbin|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;;
    *)
      # OSF1 and SCO ODT 3.0 have their own names for install.
      for ac_prog in installbsd scoinst install; do
        if test -f $ac_dir/$ac_prog; then
      if test $ac_prog = install &&
            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
        # AIX install.  It has an incompatible calling convention.
        # OSF/1 installbsd also uses dspmsg, but is usable.
        :
      else
        INSTALL="$ac_dir/$ac_prog -c"
        break 2
      fi
    fi
      done
      ;;
    esac
  done
  IFS="$ac_save_ifs"
fi

if test -z "$INSTALL"; then
  # As a last resort, use the slow shell script.
  for ac_dir in ${srcdir} ${srcdir}/.. ${srcdir}/../..; do
    if test -f $ac_dir/install.sh; then
      INSTALL=$ac_dir/install.sh; break
    fi
  done
fi
if test -z "$INSTALL"; then
  echo "configure: can not find install.sh in ${srcdir} or ${srcdir}/.. or ${srcdir}/../.." >&2; exit 1
fi
test -n "$verbose" && echo "    setting INSTALL to $INSTALL"

# Use test -z because SunOS4 sh mishandles ${INSTALL_PROGRAM-'${INSTALL}'}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
test -n "$verbose" && echo "    setting INSTALL_PROGRAM to $INSTALL_PROGRAM"

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
test -n "$verbose" && echo "    setting INSTALL_DATA to $INSTALL_DATA"

if test -z "${INSTALL}"; then
    echo "Did not find an install which i would trust. Please add it to"
    echo "config.status after this ./configure run."
    echo ""
    echo "A valid setting could be:"
    echo ""
    echo "INSTALL='/usr/bin/install -c'"
else
    echo "Will use \"${INSTALL}\" for installation."
fi
# If we find X, set shell vars x_includes and x_libraries to the paths.
no_x=true
if test "x$with_x" != xno; then
test -n "$silent" || echo "checking for X include and library files with xmkmf"
rm -fr conftestdir
if mkdir conftestdir; then
  cd conftestdir
  # Make sure to not put "make" in the Imakefile rules, since we grep it out.
  cat > Imakefile <<'EOF'
acfindx:
    @echo 'ac_im_incroot="${INCROOT}"; ac_im_usrlibdir="${USRLIBDIR}"; ac_im_libdir="${LIBDIR}"'
EOF
  if (xmkmf) >/dev/null 2>/dev/null && test -f Makefile; then
    no_x=
    # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
    eval `make acfindx 2>/dev/null | grep -v make`
    # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
    if test ! -f $ac_im_usrlibdir/libX11.a && test -f $ac_im_libdir/libX11.a
    then
      ac_im_usrlibdir=$ac_im_libdir
    fi
    case "$ac_im_incroot" in
    /usr/include) ;;
    *) test -z "$x_includes" && x_includes="$ac_im_incroot" ;;
    esac
    case "$ac_im_usrlibdir" in
    /usr/lib | /lib) ;;
    *) test -z "$x_libraries" && x_libraries="$ac_im_usrlibdir" ;;
    esac
  fi
  cd ..
  rm -fr conftestdir
fi

if test -z "$ac_im_usrlibdir"; then
test -n "$silent" || echo "checking for X include and library files directly"
if test ".$x_direct_test_library" = . ; then
   x_direct_test_library='Xt'
fi
if test ".$x_direct_test_include" = . ; then
   x_direct_test_include='X11/Intrinsic.h'
fi
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <$x_direct_test_include>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  rm -rf conftest*
  no_x=

else
  rm -rf conftest*
  for ac_dir in               \
    /usr/X11R6/include        \
    /usr/X11R5/include        \
    /usr/X11R4/include        \
                              \
    /usr/include/X11R6        \
    /usr/include/X11R5        \
    /usr/include/X11R4        \
                              \
    /usr/local/X11R6/include  \
    /usr/local/X11R5/include  \
    /usr/local/X11R4/include  \
                              \
    /usr/local/include/X11R6  \
    /usr/local/include/X11R5  \
    /usr/local/include/X11R4  \
                              \
    /usr/X11/include          \
    /usr/include/X11          \
    /usr/local/X11/include    \
    /usr/local/include/X11    \
                              \
    /usr/X386/include         \
    /usr/x386/include         \
    /usr/XFree86/include/X11  \
                              \
    /usr/include              \
    /usr/local/include        \
    /usr/unsupported/include  \
    /usr/athena/include       \
    /usr/local/x11r5/include  \
    /usr/lpp/Xamples/include  \
                              \
    /usr/openwin/include      \
    /usr/openwin/share/include \
    ; \
  do
    if test -r "$ac_dir/$x_direct_test_include"; then
      test -z "$x_includes" && x_includes=$ac_dir
      no_x=
      break
    fi
  done
fi
rm -f conftest*

# Check for the libraries.  First see if replacing the `include' by
# `lib' works.
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -l"$x_direct_test_library""
ac_have_lib=""
test -n "$silent" || echo "checking for -l"$x_direct_test_library""
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; no_x=
else
   :; for ac_dir in `echo "$x_includes" | sed s/include/lib/` \
    /usr/X11R6/lib        \
    /usr/X11R5/lib        \
    /usr/X11R4/lib        \
                          \
    /usr/lib/X11R6        \
    /usr/lib/X11R5        \
    /usr/lib/X11R4        \
                          \
    /usr/local/X11R6/lib  \
    /usr/local/X11R5/lib  \
    /usr/local/X11R4/lib  \
                          \
    /usr/local/lib/X11R6  \
    /usr/local/lib/X11R5  \
    /usr/local/lib/X11R4  \
                          \
    /usr/X11/lib          \
    /usr/lib/X11          \
    /usr/local/X11/lib    \
    /usr/local/lib/X11    \
                          \
    /usr/X386/lib         \
    /usr/x386/lib         \
    /usr/XFree86/lib/X11  \
                          \
    /usr/lib              \
    /usr/local/lib        \
    /usr/unsupported/lib  \
    /usr/athena/lib       \
    /usr/local/x11r5/lib  \
    /usr/lpp/Xamples/lib  \
                          \
    /usr/openwin/lib      \
    /usr/openwin/share/lib \
    ; \
do
  for ac_extension in a so sl; do
    if test -r $ac_dir/lib${x_direct_test_library}.$ac_extension; then
      test -z "$x_libraries" && x_libraries=$ac_dir
      no_x=
      break 2
    fi
  done
done
fi

fi
test -n "$x_includes" && test -n "$verbose" && echo "    X11 headers are in $x_includes"
test -n "$x_libraries" && test -n "$verbose" && echo "    X11 libraries are in $x_libraries"
fi

if test -z "$DIFF"; then
  # Extract the first word of `diff', so it can be a program name with args.
  set ac_dummy diff; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      DIFF="diff"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$DIFF" && DIFF=":"
test -n "$DIFF" && test -n "$verbose" && echo "    setting DIFF to $DIFF"

if test "$DIFF" = ":" ; then
    DIFF=cmp
fi
if test -z "$LEX"; then
  # Extract the first word of `flex', so it can be a program name with args.
  set ac_dummy flex; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      LEX="flex"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$LEX" && LEX="lex"
test -n "$LEX" && test -n "$verbose" && echo "    setting LEX to $LEX"

if test -z "$LEXLIB"
then
  case "$LEX" in
  flex*) ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lfl"
ac_have_lib=""
test -n "$silent" || echo "checking for -lfl"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LEXLIB="-lfl"
else
   :;
fi
 ;;
  *) LEXLIB="-ll" ;;
  esac
fi
test -n "$verbose" && echo "    setting LEXLIB to $LEXLIB"

for ac_prog in 'bison -y' byacc
do
if test -z "$YACC"; then
  # Extract the first word of `$ac_prog', so it can be a program name with args.
  set ac_dummy $ac_prog; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      YACC="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi

test -n "$YACC" && test -n "$verbose" && echo "    setting YACC to $YACC"

test -n "$YACC" && break
done
test -n "$YACC" || YACC="yacc"

if test -z "$UNCOMPRESSOR"; then
  # Extract the first word of `zcat', so it can be a program name with args.
  set ac_dummy zcat; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      UNCOMPRESSOR="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$UNCOMPRESSOR" && UNCOMPRESSOR=""zcat""
test -n "$UNCOMPRESSOR" && test -n "$verbose" && echo "    setting UNCOMPRESSOR to $UNCOMPRESSOR"

if test "$UNCOMPRESSOR" = "zcat" ; then
    echo "Warning: did not found \"zcat\" in your path"
else
    echo "Found zcat: \"$UNCOMPRESSOR\""
fi

{
test -n "$verbose" && \
echo "    defining" UNCOMPRESSOR to be "\"$UNCOMPRESSOR\""
echo "#define" UNCOMPRESSOR "\"$UNCOMPRESSOR\"" >> confdefs.h
DEFS="$DEFS -DUNCOMPRESSOR=\"$UNCOMPRESSOR\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}UNCOMPRESSOR\${ac_dB}UNCOMPRESSOR\${ac_dC}\"$UNCOMPRESSOR\"\${ac_dD}
\${ac_uA}UNCOMPRESSOR\${ac_uB}UNCOMPRESSOR\${ac_uC}\"$UNCOMPRESSOR\"\${ac_uD}
\${ac_eA}UNCOMPRESSOR\${ac_eB}UNCOMPRESSOR\${ac_eC}\"$UNCOMPRESSOR\"\${ac_eD}
"
}

if test -z "$UNZIPPER"; then
  # Extract the first word of `gzcat', so it can be a program name with args.
  set ac_dummy gzcat; ac_word=$2
  test -n "$silent" || echo "checking for $ac_word"
  IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      UNZIPPER="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$UNZIPPER" && UNZIPPER=""gzcat""
test -n "$UNZIPPER" && test -n "$verbose" && echo "    setting UNZIPPER to $UNZIPPER"

if test "$UNZIPPER" = "gzcat" ; then
    echo "Warning: did not found \"gzcat\" in your path"
else
    echo "Found zcat: \"$UNZIPPER\""
fi

{
test -n "$verbose" && \
echo "    defining" UNZIPPER to be "\"$UNZIPPER\""
echo "#define" UNZIPPER "\"$UNZIPPER\"" >> confdefs.h
DEFS="$DEFS -DUNZIPPER=\"$UNZIPPER\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}UNZIPPER\${ac_dB}UNZIPPER\${ac_dC}\"$UNZIPPER\"\${ac_dD}
\${ac_uA}UNZIPPER\${ac_uB}UNZIPPER\${ac_uC}\"$UNZIPPER\"\${ac_uD}
\${ac_eA}UNZIPPER\${ac_eB}UNZIPPER\${ac_eC}\"$UNZIPPER\"\${ac_eD}
"
}

test -n "$silent" || echo "checking for ANSI C header files"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  rm -rf conftest*
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
echo '#include "confdefs.h"
#include <string.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "memchr" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  # SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#define XOR(e,f) (((e) && !(f)) || (!(e) && (f)))
int main () { int i; for (i = 0; i < 256; i++)
if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
exit (0); }

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
echo '#include "confdefs.h"
#include <stdlib.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "free" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining STDC_HEADERS"
echo "#define" STDC_HEADERS "1" >> confdefs.h
DEFS="$DEFS -DSTDC_HEADERS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STDC_HEADERS\${ac_dB}STDC_HEADERS\${ac_dC}1\${ac_dD}
\${ac_uA}STDC_HEADERS\${ac_uB}STDC_HEADERS\${ac_uC}1\${ac_uD}
\${ac_eA}STDC_HEADERS\${ac_eB}STDC_HEADERS\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


fi
rm -fr conftest*

fi
rm -f conftest*


fi
rm -f conftest*

for ac_hdr in memory.h unistd.h string.h sys/fcntl.h sys/select.h sys/shm.h netinet/in.h sys/socket.h netdb.h
do
ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./' '[A-Z]__'`
test -n "$silent" || echo "checking for ${ac_hdr}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <${ac_hdr}>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining ${ac_tr_hdr}"
echo "#define" ${ac_tr_hdr} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_hdr}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_hdr}\${ac_dB}${ac_tr_hdr}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_hdr}\${ac_uB}${ac_tr_hdr}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_hdr}\${ac_eB}${ac_tr_hdr}\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*
done

echo '#include "confdefs.h"
#include <regexp.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "getrnge" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_GETRNGE"
echo "#define" HAVE_GETRNGE "1" >> confdefs.h
DEFS="$DEFS -DHAVE_GETRNGE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GETRNGE\${ac_dB}HAVE_GETRNGE\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_GETRNGE\${ac_uB}HAVE_GETRNGE\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_GETRNGE\${ac_eB}HAVE_GETRNGE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking for -lsocket needed"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { socket();
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  echo "Your linker seems to be happy without -lsocket"

else
  rm -rf conftest*
  ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lsocket"
ac_have_lib=""
test -n "$silent" || echo "checking for -lsocket"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lsocket"
else
   :;
fi

fi
rm -f conftest*

test -n "$silent" || echo "checking for -lnsl needed"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { gethostbyname();
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  echo "Your linker seems to be happy without -lnsl" ;

else
  rm -rf conftest*
  ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lnsl"
ac_have_lib=""
test -n "$silent" || echo "checking for -lnsl"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lnsl"
else
   :;
fi

fi
rm -f conftest*

test -n "$silent" || echo "checking for -lmalloc needed"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { malloc();
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  echo "Your linker seems to be happy without -lmalloc" ;

else
  rm -rf conftest*
  ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lmalloc"
ac_have_lib=""
test -n "$silent" || echo "checking for -lmalloc"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lmalloc"
else
   :;
fi

fi
rm -f conftest*

ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lcs"
ac_have_lib=""
test -n "$silent" || echo "checking for -lcs"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  ac_have_lib="1"

fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
   :; LIBS="$LIBS -lcs"
else
   :;
fi

# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments.  Useless!
test -n "$silent" || echo "checking for working alloca.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <alloca.h>
int main() { return 0; }
int t() { char *p = alloca(2 * sizeof(int));; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_ALLOCA_H"
echo "#define" HAVE_ALLOCA_H "1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALLOCA_H=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA_H\${ac_dB}HAVE_ALLOCA_H\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_ALLOCA_H\${ac_uB}HAVE_ALLOCA_H\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_ALLOCA_H\${ac_eB}HAVE_ALLOCA_H\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

ac_decl="#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#if HAVE_ALLOCA_H
#include <alloca.h>
#else
#ifdef _AIX
 #pragma alloca
#else
char *alloca ();
#endif
#endif
#endif
"
test -n "$silent" || echo "checking for alloca"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_decl
int main() { return 0; }
int t() { char *p = (char *) alloca(1);; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_ALLOCA"
echo "#define" HAVE_ALLOCA "1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALLOCA=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA\${ac_dB}HAVE_ALLOCA\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_ALLOCA\${ac_uB}HAVE_ALLOCA\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_ALLOCA\${ac_eB}HAVE_ALLOCA\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  ac_alloca_missing=1
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#if defined(CRAY) && ! defined(CRAY2)
winnitude
#else
lossage
#endif

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "winnitude" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  test -n "$silent" || echo "checking for _getb67"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 0; }
int t() {
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub__getb67) || defined (__stub____getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char _getb67(); _getb67();
#endif
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining" CRAY_STACKSEG_END to be "_getb67"
echo "#define" CRAY_STACKSEG_END "_getb67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}_getb67\${ac_dD}
\${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}_getb67\${ac_uD}
\${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}_getb67\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for GETB67"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 0; }
int t() {
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_GETB67) || defined (__stub___GETB67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char GETB67(); GETB67();
#endif
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining" CRAY_STACKSEG_END to be "GETB67"
echo "#define" CRAY_STACKSEG_END "GETB67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}GETB67\${ac_dD}
\${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}GETB67\${ac_uD}
\${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}GETB67\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for getb67"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 0; }
int t() {
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_getb67) || defined (__stub___getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char getb67(); getb67();
#endif
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining" CRAY_STACKSEG_END to be "getb67"
echo "#define" CRAY_STACKSEG_END "getb67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=getb67"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}getb67\${ac_dD}
\${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}getb67\${ac_uD}
\${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}getb67\${ac_eD}
"
}


fi
rm -f conftest*

fi
rm -f conftest*

fi
rm -f conftest*


fi
rm -f conftest*


fi
rm -f conftest*

if test -n "$ac_alloca_missing"; then
  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
  # that cause trouble.  Some versions do not even contain alloca or
  # contain a buggy version.  If you still want to use their alloca,
  # use ar to extract alloca.o from them instead of compiling alloca.c.
  ALLOCA=alloca.o

{
test -n "$verbose" && \
echo "    defining C_ALLOCA"
echo "#define" C_ALLOCA "1" >> confdefs.h
DEFS="$DEFS -DC_ALLOCA=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}C_ALLOCA\${ac_dB}C_ALLOCA\${ac_dC}1\${ac_dD}
\${ac_uA}C_ALLOCA\${ac_uB}C_ALLOCA\${ac_uC}1\${ac_uD}
\${ac_eA}C_ALLOCA\${ac_eB}C_ALLOCA\${ac_eC}1\${ac_eD}
"
}


  test -n "$silent" || echo "checking stack direction for C alloca"
  test -n "$silent" || echo "checking whether cross-compiling"
# If we cannot run a trivial program, we must be cross compiling.
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
main(){exit(0);}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  cross_compiling=1
fi
rm -fr conftest*

if test -n "$cross_compiling"
then

{
test -n "$verbose" && \
echo "    defining" STACK_DIRECTION to be "0"
echo "#define" STACK_DIRECTION "0" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=0"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}0\${ac_dD}
\${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}0\${ac_uD}
\${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}0\${ac_eD}
"
}

else
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
find_stack_direction ()
{
  static char *addr = 0;
  auto char dummy;
  if (addr == 0)
    {
      addr = &dummy;
      return find_stack_direction ();
    }
  else
    return (&dummy > addr) ? 1 : -1;
}
main ()
{
  exit (find_stack_direction() < 0);
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining" STACK_DIRECTION to be "1"
echo "#define" STACK_DIRECTION "1" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}1\${ac_dD}
\${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}1\${ac_uD}
\${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}1\${ac_eD}
"
}


else

{
test -n "$verbose" && \
echo "    defining" STACK_DIRECTION to be "-1"
echo "#define" STACK_DIRECTION "-1" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=-1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}-1\${ac_dD}
\${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}-1\${ac_uD}
\${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}-1\${ac_eD}
"
}

fi
fi
rm -fr conftest*
fi

echo '#include "confdefs.h"
#include <dirent.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "alphasort" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_ALPHASORT"
echo "#define" HAVE_ALPHASORT "1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALPHASORT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALPHASORT\${ac_dB}HAVE_ALPHASORT\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_ALPHASORT\${ac_uB}HAVE_ALPHASORT\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_ALPHASORT\${ac_eB}HAVE_ALPHASORT\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

echo '#include "confdefs.h"
#include <dirent.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "scandir" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_SCANDIR"
echo "#define" HAVE_SCANDIR "1" >> confdefs.h
DEFS="$DEFS -DHAVE_SCANDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_SCANDIR\${ac_dB}HAVE_SCANDIR\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_SCANDIR\${ac_uB}HAVE_SCANDIR\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_SCANDIR\${ac_eB}HAVE_SCANDIR\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

echo '#include "confdefs.h"
#include <stdio.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "remove" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_REMOVE"
echo "#define" HAVE_REMOVE "1" >> confdefs.h
DEFS="$DEFS -DHAVE_REMOVE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_REMOVE\${ac_dB}HAVE_REMOVE\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_REMOVE\${ac_uB}HAVE_REMOVE\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_REMOVE\${ac_eB}HAVE_REMOVE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

echo '#include "confdefs.h"
#include <unistd.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "getcwd" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_GETCWD"
echo "#define" HAVE_GETCWD "1" >> confdefs.h
DEFS="$DEFS -DHAVE_GETCWD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GETCWD\${ac_dB}HAVE_GETCWD\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_GETCWD\${ac_uB}HAVE_GETCWD\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_GETCWD\${ac_eB}HAVE_GETCWD\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

echo '#include "confdefs.h"
#include <unistd.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "getwd" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_GETWD"
echo "#define" HAVE_GETWD "1" >> confdefs.h
DEFS="$DEFS -DHAVE_GETWD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GETWD\${ac_dB}HAVE_GETWD\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_GETWD\${ac_uB}HAVE_GETWD\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_GETWD\${ac_eB}HAVE_GETWD\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

for ac_func in memcpy bcopy memmove strdup
do
ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'`
test -n "$silent" || echo "checking for ${ac_func}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 0; }
int t() {
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${ac_func}) || defined (__stub___${ac_func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${ac_func}(); ${ac_func}();
#endif
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining ${ac_tr_func}"
echo "#define" ${ac_tr_func} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_func}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*
done

case "$DEFS" in
    *HAVE_MEMCPY* )
echo "Checking to see if your memcpy() can do overlapping copies..."
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

main()
{
char buf[128], abc[128];
char *b;
int len;
int off;
int align;

memcpy(abc, "abcdefghijklmnopqrstuvwxyz0123456789", 36);

for (align = 7; align >= 0; align--) {
    for (len = 36; len; len--) {
        b = buf+align;
        memcpy(abc, b, len);
        for (off = 1; off <= len; off++) {
            memcpy(b, b+off, len);
            memcpy(b+off, b, len);
            if (memcmp(b, abc, len))
                exit(1);
        }
    }
}
exit(0);
}


EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  echo "Yes, it can." ;
{
test -n "$verbose" && \
echo "    defining MEMCPY_OVERLAP"
echo "#define" MEMCPY_OVERLAP "1" >> confdefs.h
DEFS="$DEFS -DMEMCPY_OVERLAP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}MEMCPY_OVERLAP\${ac_dB}MEMCPY_OVERLAP\${ac_dC}1\${ac_dD}
\${ac_uA}MEMCPY_OVERLAP\${ac_uB}MEMCPY_OVERLAP\${ac_uC}1\${ac_uD}
\${ac_eA}MEMCPY_OVERLAP\${ac_eB}MEMCPY_OVERLAP\${ac_eC}1\${ac_eD}
"
}


else
  echo "It can't, sorry."
fi
rm -fr conftest*
;;
esac

case "$DEFS" in
*HAVE_BCOPY*)
echo "Checking to see if your bcopy() can do overlapping copies..."
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

main()
{
char buf[128], abc[128];
char *b;
int len;
int off;
int align;
bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36);

for (align = 7; align >= 0; align--) {
    for (len = 36; len; len--) {
        b = buf+align;
        bcopy(abc, b, len);
        for (off = 1; off <= len; off++) {
            bcopy(b, b+off, len);
            bcopy(b+off, b, len);
            if (bcmp(b, abc, len))
                exit(1);
        }
    }
}
exit(0);
}

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  echo "Yes, it can." ;
{
test -n "$verbose" && \
echo "    defining BCOPY_OVERLAP"
echo "#define" BCOPY_OVERLAP "1" >> confdefs.h
DEFS="$DEFS -DBCOPY_OVERLAP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}BCOPY_OVERLAP\${ac_dB}BCOPY_OVERLAP\${ac_dC}1\${ac_dD}
\${ac_uA}BCOPY_OVERLAP\${ac_uB}BCOPY_OVERLAP\${ac_uC}1\${ac_uD}
\${ac_eA}BCOPY_OVERLAP\${ac_eB}BCOPY_OVERLAP\${ac_eC}1\${ac_eD}
"
}


else
  echo "It can't, sorry."
fi
rm -fr conftest*
;;
esac

test -n "$silent" || echo "checking for whether time.h and sys/time.h may both be included"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/time.h>
#include <time.h>
int main() { return 0; }
int t() { struct tm *tp;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining TIME_WITH_SYS_TIME"
echo "#define" TIME_WITH_SYS_TIME "1" >> confdefs.h
DEFS="$DEFS -DTIME_WITH_SYS_TIME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TIME_WITH_SYS_TIME\${ac_dB}TIME_WITH_SYS_TIME\${ac_dC}1\${ac_dD}
\${ac_uA}TIME_WITH_SYS_TIME\${ac_uB}TIME_WITH_SYS_TIME\${ac_uC}1\${ac_uD}
\${ac_eA}TIME_WITH_SYS_TIME\${ac_eB}TIME_WITH_SYS_TIME\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking for struct tm in time.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <time.h>
int main() { return 0; }
int t() { struct tm *tp; tp->tm_sec;; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining TM_IN_SYS_TIME"
echo "#define" TM_IN_SYS_TIME "1" >> confdefs.h
DEFS="$DEFS -DTM_IN_SYS_TIME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TM_IN_SYS_TIME\${ac_dB}TM_IN_SYS_TIME\${ac_dC}1\${ac_dD}
\${ac_uA}TM_IN_SYS_TIME\${ac_uB}TM_IN_SYS_TIME\${ac_uC}1\${ac_uD}
\${ac_eA}TM_IN_SYS_TIME\${ac_eB}TM_IN_SYS_TIME\${ac_eC}1\${ac_eD}
"
}

fi
rm -f conftest*

test -n "$silent" || echo "checking for unsigned characters"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
/* volatile prevents gcc2 from optimizing the test away on sparcs.  */
#if !__STDC__
#define volatile
#endif
main() {
#ifdef __CHAR_UNSIGNED__
  exit(1); /* No need to redefine it.  */
#else
  volatile char c = 255; exit(c < 0);
#endif
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining __CHAR_UNSIGNED__"
echo "#define" __CHAR_UNSIGNED__ "1" >> confdefs.h
DEFS="$DEFS -D__CHAR_UNSIGNED__=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}__CHAR_UNSIGNED__\${ac_dB}__CHAR_UNSIGNED__\${ac_dC}1\${ac_dD}
\${ac_uA}__CHAR_UNSIGNED__\${ac_uB}__CHAR_UNSIGNED__\${ac_uC}1\${ac_uD}
\${ac_eA}__CHAR_UNSIGNED__\${ac_eB}__CHAR_UNSIGNED__\${ac_eC}1\${ac_eD}
"
}


fi
rm -fr conftest*

ac_prog='/* Ultrix mips cc rejects this.  */
typedef int charset[2]; const charset x;
/* SunOS 4.1.1 cc rejects this.  */
char const *const *ccp;
char **p;
/* AIX XL C 1.02.0.0 rejects this.
   It does not let you subtract one const X* pointer from another in an arm
   of an if-expression whose if-part is not a constant expression */
const char *g = "string";
ccp = &g + (g ? g-g : 0);
/* HPUX 7.0 cc rejects these. */
++ccp;
p = (char**) ccp;
ccp = (char const *const *) p;
{ /* SCO 3.2v4 cc rejects this.  */
  char *t;
  char const *s = 0 ? (char *) 0 : (char const *) 0;

  *t++ = 0;
}
{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
  int x[] = {25,17};
  const int *foo = &x[0];
  ++foo;
}
{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
  typedef const int *iptr;
  iptr p = 0;
  ++p;
}
{ /* AIX XL C 1.02.0.0 rejects this saying
     "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
  struct s { int j; const int *ap[3]; };
  struct s *b; b->j = 5;
}
{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
  const int foo = 10;
}'
test -n "$silent" || echo "checking for lack of working const"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { $ac_prog; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining" const to be empty
echo "#define" const "" >> confdefs.h
DEFS="$DEFS -Dconst="
ac_sed_defs="${ac_sed_defs}\${ac_dA}const\${ac_dB}const\${ac_dC}\${ac_dD}
\${ac_uA}const\${ac_uB}const\${ac_uC}\${ac_uD}
\${ac_eA}const\${ac_eB}const\${ac_eC}\${ac_eD}
"
}

fi
rm -f conftest*

test -n "$silent" || echo "checking for inet_ntoa with struct argument"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() { return 0; }
int t() {
struct sockaddr_in source;
inet_ntoa(source.sin_addr)
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining INET_NTOA_WITH_STRUCT"
echo "#define" INET_NTOA_WITH_STRUCT "1" >> confdefs.h
DEFS="$DEFS -DINET_NTOA_WITH_STRUCT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}INET_NTOA_WITH_STRUCT\${ac_dB}INET_NTOA_WITH_STRUCT\${ac_dC}1\${ac_dD}
\${ac_uA}INET_NTOA_WITH_STRUCT\${ac_uB}INET_NTOA_WITH_STRUCT\${ac_uC}1\${ac_uD}
\${ac_eA}INET_NTOA_WITH_STRUCT\${ac_eB}INET_NTOA_WITH_STRUCT\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking for inet_ntoa with pointer argument"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() { return 0; }
int t() {
struct sockaddr_in source;
inet_ntoa(&source.sin_addr)
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining INET_NTOA_WITH_POINTER"
echo "#define" INET_NTOA_WITH_POINTER "1" >> confdefs.h
DEFS="$DEFS -DINET_NTOA_WITH_POINTER=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}INET_NTOA_WITH_POINTER\${ac_dB}INET_NTOA_WITH_POINTER\${ac_dC}1\${ac_dD}
\${ac_uA}INET_NTOA_WITH_POINTER\${ac_uB}INET_NTOA_WITH_POINTER\${ac_uC}1\${ac_uD}
\${ac_eA}INET_NTOA_WITH_POINTER\${ac_eB}INET_NTOA_WITH_POINTER\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


echo checking for ctype.h
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <ctype.h>
#ifndef HAVE_BCOPY
#define bcopy(s, d, n) memcpy ((d), (s), (n))
#endif
unsigned char ctype[256];
main()
{
     bcopy(_ctype_,ctype,256*sizeof(char));
     exit(0);
}

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining" CTYPEVAR to be "_ctype_"
echo "#define" CTYPEVAR "_ctype_" >> confdefs.h
DEFS="$DEFS -DCTYPEVAR=_ctype_"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CTYPEVAR\${ac_dB}CTYPEVAR\${ac_dC}_ctype_\${ac_dD}
\${ac_uA}CTYPEVAR\${ac_uB}CTYPEVAR\${ac_uC}_ctype_\${ac_uD}
\${ac_eA}CTYPEVAR\${ac_eB}CTYPEVAR\${ac_eC}_ctype_\${ac_eD}
"
}


fi
rm -fr conftest*
echo checking for regexp.h
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#define INIT register char *regexp=instring;
#define GETC() (*regexp++)
#define PEEKC() (*regexp)
#define UNGETC(c) (regexp--)
#define RETURN(pointer) return(0);          /* return 0 on sucess */
#define ERROR(val) return((char *) val);    /* return error code on failure */
#include <regexp.h>
main()
{
        circf = 1;
        exit(0);
}

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  REGEXP=1

else
  REGEXP=0;echo failed
fi
rm -fr conftest*


if test "1" = "$REGEXP" ; then
    echo "Do you want to use your systems regexp.h (no)?";
read usereg;
if test "$usereg" = "" ; then
        usereg="no";
fi
    if test "$usereg" = "no" ; then
        REGEXP=0;
    fi
fi
if test "0" = "$REGEXP" ; then
    {

{
test -n "$verbose" && \
echo "    defining SYSVREGEXP"
echo "#define" SYSVREGEXP "1" >> confdefs.h
DEFS="$DEFS -DSYSVREGEXP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSVREGEXP\${ac_dB}SYSVREGEXP\${ac_dC}1\${ac_dD}
\${ac_uA}SYSVREGEXP\${ac_uB}SYSVREGEXP\${ac_uC}1\${ac_uD}
\${ac_eA}SYSVREGEXP\${ac_eB}SYSVREGEXP\${ac_eC}1\${ac_eD}
"
}

    REGEXPLIB=../regexp/libregexp.a
    SUBDIRS=regexp
    echo "Ok, will use my own regxep.h";
    }
else
    echo "Ok, will stick with your REGXEP";
fi

echo "Will you have HEADLINE files greater than 16 MB (no)?";
read huge_headlines;
if test "$huge_headlines" = "" ; then
        huge_headlines="no";
fi

if test "$huge_headlines" = "yes" ; then
        {

{
test -n "$verbose" && \
echo "    defining HUGE_HEADLINES"
echo "#define" HUGE_HEADLINES "1" >> confdefs.h
DEFS="$DEFS -DHUGE_HEADLINES=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HUGE_HEADLINES\${ac_dB}HUGE_HEADLINES\${ac_dC}1\${ac_dD}
\${ac_uA}HUGE_HEADLINES\${ac_uB}HUGE_HEADLINES\${ac_uC}1\${ac_uD}
\${ac_eA}HUGE_HEADLINES\${ac_eB}HUGE_HEADLINES\${ac_eC}1\${ac_eD}
"
}
        echo "Note that old indexes are invalid for the new server" ;
        }
else
        echo "Ok, no huge headlines; old indexes remain valid" ;
fi


echo ""
echo You can compile freeWAIS-sf with it\'s own ctype package. You
echo should do this, if you want to use special "(country specific)"
echo chars, which are not supported by your systems ctype.

echo "Use your systems ctype (no)?";
read iso;
if test "$iso" = "" ; then
        iso="no";
fi
if test "$iso" = "no" ; then
    echo "Ok, will use my own ctype";
    INC="${INC} -I../ctype"
    SUBDIRS="ctype ${SUBDIRS}"
    LFLAGS="${LFLAGS} -8"
    ISOOBJS=../ctype/ctype.o

{
test -n "$verbose" && \
echo "    defining ISO"
echo "#define" ISO "1" >> confdefs.h
DEFS="$DEFS -DISO=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}ISO\${ac_dB}ISO\${ac_dC}1\${ac_dD}
\${ac_uA}ISO\${ac_uB}ISO\${ac_uC}1\${ac_uD}
\${ac_eA}ISO\${ac_eB}ISO\${ac_eC}1\${ac_eD}
"
}

    echo ""
    echo I will now ask for your special letters.  If you do not want
    echo to give the now, edit Default.tmpl after this configure run.
    echo Input your upper case letters in the same order than your
    echo lower case letters. "toupper() and tolower()" depend on this
    echo order. Input letters wich are upper and lower case in both
    echo strings.

    echo "what are your lower case letters ("Σ÷ⁿ▀")?";
read lchars;
if test "$lchars" = "" ; then
        lchars=""Σ÷ⁿ▀"";
fi

{
test -n "$verbose" && \
echo "    defining" LCHARS to be "\"$lchars\""
echo "#define" LCHARS "\"$lchars\"" >> confdefs.h
DEFS="$DEFS -DLCHARS=\"$lchars\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}LCHARS\${ac_dB}LCHARS\${ac_dC}\"$lchars\"\${ac_dD}
\${ac_uA}LCHARS\${ac_uB}LCHARS\${ac_uC}\"$lchars\"\${ac_uD}
\${ac_eA}LCHARS\${ac_eB}LCHARS\${ac_eC}\"$lchars\"\${ac_eD}
"
}

    echo "what are your upper case letters ("─╓▄▀")?";
read uchars;
if test "$uchars" = "" ; then
        uchars=""─╓▄▀"";
fi

{
test -n "$verbose" && \
echo "    defining" UCHARS to be "\"$uchars\""
echo "#define" UCHARS "\"$uchars\"" >> confdefs.h
DEFS="$DEFS -DUCHARS=\"$uchars\""
ac_sed_defs="${ac_sed_defs}\${ac_dA}UCHARS\${ac_dB}UCHARS\${ac_dC}\"$uchars\"\${ac_dD}
\${ac_uA}UCHARS\${ac_uB}UCHARS\${ac_uC}\"$uchars\"\${ac_uD}
\${ac_eA}UCHARS\${ac_eB}UCHARS\${ac_eC}\"$uchars\"\${ac_eD}
"
}

    if test "$LEX" != "flex" ; then
          echo "Note that you can not reconstruct ir/query_l.c from"
          echo "ir/query_l.l, since you don't have flex!";
    fi
else
    echo "Ok, will use your systems ctype";
fi

echo ""
echo You can compile and link the clients with the capability to
echo search index files directely. So you need not to install a
echo server, for local searches. The clients will be greater, but
echo faster with local searches.
echo You can not run the test without the switch

echo "Do you want to compile with -DLOCAL_SEARCH (yes)?";
read local;
if test "$local" = "" ; then
        local="yes";
fi

if test "$local" = "yes" ; then
    echo "Ok, will compile with the -DLOCAL_SEARCH switch"

{
test -n "$verbose" && \
echo "    defining LOCAL_SEARCH"
echo "#define" LOCAL_SEARCH "1" >> confdefs.h
DEFS="$DEFS -DLOCAL_SEARCH=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}LOCAL_SEARCH\${ac_dB}LOCAL_SEARCH\${ac_dC}1\${ac_dD}
\${ac_uA}LOCAL_SEARCH\${ac_uB}LOCAL_SEARCH\${ac_uC}1\${ac_uD}
\${ac_eA}LOCAL_SEARCH\${ac_eB}LOCAL_SEARCH\${ac_eC}1\${ac_eD}
"
}

    LIBLOCAL=../ir/liblocal.a
    TESTDIR="FIELD-EXAMPLE"

else
    echo "Ok, will compile with no -DLOCAL_SEARCH switch"
    echo "Note: will not be able to run the tests"
fi

echo ""
echo "You can modify the URL document type, to put the URL of the"
echo "indexed in the document id instead of the headline. If you use"
echo "this modification you can customize the headline (e.g. with the"
echo "-t fields option). Also it is not required to keep a copy of the"
echo "documents for retrieval with the wais server. But currently only"
echo "SFgate can handle this modified docids. Normal clients will not"
echo "correctely interprete the docids and try to retrieve the document"
echo "from a wais instead of the correspondig http server."
echo ""

echo "Do you want to use the modified URL handling (no)?";
read urldocid;
if test "$urldocid" = "" ; then
        urldocid="no";
fi

if test "$urldocid" = "no" ; then
    echo "Ok, will use the original doctype URL"
else
    echo "Ok, will use the modified URL doctype"
    echo "Note: you will not be able to retrieve URL documents with"
    echo "      clients other than SFgate"

{
test -n "$verbose" && \
echo "    defining URLDOCID"
echo "#define" URLDOCID "1" >> confdefs.h
DEFS="$DEFS -DURLDOCID=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}URLDOCID\${ac_dB}URLDOCID\${ac_dC}1\${ac_dD}
\${ac_uA}URLDOCID\${ac_uB}URLDOCID\${ac_uC}1\${ac_uD}
\${ac_eA}URLDOCID\${ac_eB}URLDOCID\${ac_eC}1\${ac_eD}
"
}

fi

if test "$prefix" = "" ; then
    prefix="/usr/local/wais";
fi

echo "Where should the installation go ($prefix)?";
read INSTALLROOT;
if test "$INSTALLROOT" = "" ; then
        INSTALLROOT="$prefix";
fi
prefix="$INSTALLROOT"
echo "Ok, will install in $INSTALLROOT"


case "$DEFS" in
    *HAVE_SYS_SHM* )
echo "

I added a patch from Alberto Accomazzi for speeding up usage of
synonym files. He writes about his patch:

For those of you who have fairly large synonym files (> 10Kb) and are
running the software on a machine that supports shared memory (your
machine does) enabling this feature will speed up the waisserver
response time by a significant factor.

For those of you who do not have shared memory, I have rewritten the
memory allocation part of synonym.c so that bigger memory chunks are
allocated and used rather than allocating memory for each word and
synonym, so the code should be a little faster for you too.
"

echo "Do you want to use shm cache (no)?";
read CACHE_SYN;
if test "$CACHE_SYN" = "" ; then
        CACHE_SYN="no";
fi
    if test "$CACHE_SYN" != "no" ; then
        echo "Ok. The shared memory support will be compiled in."

{
test -n "$verbose" && \
echo "    defining CACHE_SYN"
echo "#define" CACHE_SYN "1" >> confdefs.h
DEFS="$DEFS -DCACHE_SYN=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CACHE_SYN\${ac_dB}CACHE_SYN\${ac_dC}1\${ac_dD}
\${ac_uA}CACHE_SYN\${ac_uB}CACHE_SYN\${ac_uC}1\${ac_uD}
\${ac_eA}CACHE_SYN\${ac_eB}CACHE_SYN\${ac_eC}1\${ac_eD}
"
}

    else
        echo "Ok. Will not compile the shared memory support."
    fi
;;
esac

echo "

As distributed, $FREE_WAIS_SF_VERSION_STRING will send an UDP packet
to my workstation every time waisserver reindexes his info database,
containing your (numeric) UID, your operating system, your compiler
version and the $DISTNAME version.

This is JUST because I would like to get an idea of to which
systems/compilers $DISTNAME has be ported and how many people use it,
and keep on using it (rather than "tried it once" folks).  It will
NEVER become a licensing scheme or some crazy thing like that.  But,
you can disable it by answering 'yes' to the following question.  If
you do that, please let me know, if you are running $DISTNAME on a
system/compiler, which is not mentioned in the README.
"

echo "Disable the UDP packet sending (no)?";
read DO_NOT_TELL_ABOUT_ME;
if test "$DO_NOT_TELL_ABOUT_ME" = "" ; then
        DO_NOT_TELL_ABOUT_ME="no";
fi
if test "$DO_NOT_TELL_ABOUT_ME" = "yes" ; then

{
test -n "$verbose" && \
echo "    defining DO_NOT_TELL_ABOUT_ME"
echo "#define" DO_NOT_TELL_ABOUT_ME "1" >> confdefs.h
DEFS="$DEFS -DDO_NOT_TELL_ABOUT_ME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}DO_NOT_TELL_ABOUT_ME\${ac_dB}DO_NOT_TELL_ABOUT_ME\${ac_dC}1\${ac_dD}
\${ac_uA}DO_NOT_TELL_ABOUT_ME\${ac_uB}DO_NOT_TELL_ABOUT_ME\${ac_uC}1\${ac_uD}
\${ac_eA}DO_NOT_TELL_ABOUT_ME\${ac_eB}DO_NOT_TELL_ABOUT_ME\${ac_eC}1\${ac_eD}
"
}

    echo "Ok. I'll respect your privacy."
else
    echo "Ok. Thank you for your trust."
fi











generate_imake=1


# Set default prefixes.
if test -n "$prefix"; then
  test -z "$exec_prefix" && exec_prefix='${prefix}' # Let make expand it.
  ac_prsub="s%^prefix\\([     ]*\\)=\\([     ]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
  ac_prsub="$ac_prsub
s%^exec_prefix\\([     ]*\\)=\\([     ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
fi
# Any assignment to VPATH causes Sun make to only execute
# the first set of double-colon rules, so remove it if not needed.
# If there is a colon in the path, we need to keep it.
if test "x$srcdir" = x.; then
  ac_vpsub='/^[     ]*VPATH[     ]*=[^:]*$/d'
fi

# Quote sed substitution magic chars in DEFS.
cat >conftest.def <<EOF
$DEFS
EOF
ac_escape_ampersand_and_backslash='s%[&\\]%\\&%g'
DEFS=`sed "$ac_escape_ampersand_and_backslash" <conftest.def`
rm -f conftest.def
# Substitute for predefined variables.

trap 'rm -f config.status; exit 1' 1 2 15
echo creating config.status
rm -f config.status
cat > config.status <<EOF
#!/bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $configure_args

ac_cs_usage="Usage: config.status [--recheck] [--version] [--help]"
for ac_option
do
  case "\$ac_option" in
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create
    exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create ;;
  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
    echo "config.status generated by autoconf version 1.10"
    exit 0 ;;
  -help | --help | --hel | --he | --h)
    echo "\$ac_cs_usage"; exit 0 ;;
  *) echo "\$ac_cs_usage"; exit 1 ;;
  esac
done

trap 'rm -fr Install.tmpl Makefile ctype/Makefile regexp/Makefile
lib/Makefile ir/Makefile ui/Makefile x/Makefile
FIELD-EXAMPLE/Makefile Defaults.tmpl conftest*; exit 1' 1 2 15
FREE_WAIS_SF_VERSION='$FREE_WAIS_SF_VERSION'
DISTNAME='$DISTNAME'
CFLAGS='$CFLAGS'
CC='$CC'
CPP='$CPP'
PCPP='$PCPP'
RANLIB='$RANLIB'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
DIFF='$DIFF'
LEX='$LEX'
LEXLIB='$LEXLIB'
YACC='$YACC'
UNCOMPRESSOR='$UNCOMPRESSOR'
UNZIPPER='$UNZIPPER'
ALLOCA='$ALLOCA'
TESTDIR='$TESTDIR'
INSTALLROOT='$INSTALLROOT'
INC='$INC'
LFLAGS='$LFLAGS'
ISOOBJS='$ISOOBJS'
REGEXPLIB='$REGEXPLIB'
LIBLOCAL='$LIBLOCAL'
x_includes='$x_includes'
x_libraries='$x_libraries'
SUBDIRS='$SUBDIRS'
generate_imake='$generate_imake'
LIBS='$LIBS'
srcdir='$srcdir'
top_srcdir='$top_srcdir'
prefix='$prefix'
exec_prefix='$exec_prefix'
ac_prsub='$ac_prsub'
ac_vpsub='$ac_vpsub'
extrasub='$extrasub'
EOF
cat >> config.status <<\EOF

ac_given_srcdir=$srcdir

CONFIG_FILES=${CONFIG_FILES-"Install.tmpl Makefile ctype/Makefile regexp/Makefile
lib/Makefile ir/Makefile ui/Makefile x/Makefile
FIELD-EXAMPLE/Makefile"}
for ac_file in .. ${CONFIG_FILES}; do if test "x$ac_file" != x..; then
  # Remove last slash and all that follows it.  Not all systems have dirname.
  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
  if test "$ac_dir" != "$ac_file"; then
    # The file is in a subdirectory.
    test ! -d "$ac_dir" && mkdir "$ac_dir"
    ac_dir_suffix="/$ac_dir"
  else
    ac_dir_suffix=
  fi

  # A "../" for each directory in $ac_dir_suffix.
  ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
  case "$ac_given_srcdir" in
  .)  srcdir=.; top_srcdir="$ac_dots." ;;
  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
  *) # Relative path.
    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
    top_srcdir="$ac_dots$ac_given_srcdir" ;;
  esac

  echo creating "$ac_file"
  rm -f "$ac_file"
  comment_str="Generated automatically from `echo $ac_file|sed 's|.*/||'`.in by configure."
  case "$ac_file" in
    *.html ) echo "<!-- $comment_str  -->" > "$ac_file" ;;
    *.c | *.h | *.C | *.cc | *.m | *.tmpl )  echo "/* $comment_str */" > "$ac_file" ;;
    * )          echo "# $comment_str"     > "$ac_file" ;;
  esac
  sed -e "
$ac_prsub
$ac_vpsub
$extrasub
s%@FREE_WAIS_SF_VERSION@%$FREE_WAIS_SF_VERSION%g
s%@DISTNAME@%$DISTNAME%g
s%@CFLAGS@%$CFLAGS%g
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@PCPP@%$PCPP%g
s%@RANLIB@%$RANLIB%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@DIFF@%$DIFF%g
s%@LEX@%$LEX%g
s%@LEXLIB@%$LEXLIB%g
s%@YACC@%$YACC%g
s%@UNCOMPRESSOR@%$UNCOMPRESSOR%g
s%@UNZIPPER@%$UNZIPPER%g
s%@ALLOCA@%$ALLOCA%g
s%@TESTDIR@%$TESTDIR%g
s%@INSTALLROOT@%$INSTALLROOT%g
s%@INC@%$INC%g
s%@LFLAGS@%$LFLAGS%g
s%@ISOOBJS@%$ISOOBJS%g
s%@REGEXPLIB@%$REGEXPLIB%g
s%@LIBLOCAL@%$LIBLOCAL%g
s%@x_includes@%$x_includes%g
s%@x_libraries@%$x_libraries%g
s%@SUBDIRS@%$SUBDIRS%g
s%@generate_imake@%$generate_imake%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@top_srcdir@%$top_srcdir%g
s%@prefix@%$prefix%g
s%@exec_prefix@%$exec_prefix%g
s%@DEFS@%-DHAVE_CONFIG_H%" $ac_given_srcdir/${ac_file}.in >> $ac_file
fi; done

# These sed commands are put into ac_sed_defs when defining a macro.
# They are broken into pieces to make the sed script easier to manage.
# They are passed to sed as "A NAME B NAME C VALUE D", where NAME
# is the cpp macro being defined and VALUE is the value it is being given.
# Each defining turns into a single global substitution command.
# Hopefully no one uses "!" as a variable value.
# Other candidates for the sed separators, like , and @, do get used.
#
# ac_d sets the value in "#define NAME VALUE" lines.
ac_dA='s!^\([     ]*\)#\([     ]*define[     ][     ]*\)'
ac_dB='\([     ][     ]*\)[^     ]*!\1#\2'
ac_dC='\3'
ac_dD='!g'
# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
ac_uA='s!^\([     ]*\)#\([     ]*\)undef\([     ][     ]*\)'
ac_uB='\([     ]\)!\1#\2define\3'
ac_uC=' '
ac_uD='\4!g'
# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
ac_eA='s!^\([     ]*\)#\([     ]*\)undef\([     ][     ]*\)'
ac_eB='$!\1#\2define\3'
ac_eC=' '
ac_eD='!g'
rm -f conftest.sed
EOF
# Turn off quoting long enough to insert the sed commands.
rm -f conftest.sh
cat > conftest.sh <<EOF
$ac_sed_defs
EOF

# Break up $ac_sed_defs (now in conftest.sh) because some shells have a limit
# on the size of here documents.

# Maximum number of lines to put in a single here document.
ac_max_sh_lines=9

while :
do
  # wc gives bogus results for an empty file on some AIX systems.
  ac_lines=`grep -c . conftest.sh`
  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
  rm -f conftest.s1 conftest.s2
  sed ${ac_max_sh_lines}q conftest.sh > conftest.s1 # Like head -9.
  sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +10.
  # Write a limited-size here document to append to conftest.sed.
  echo 'cat >> conftest.sed <<CONFEOF' >> config.status
  cat conftest.s1 >> config.status
  echo 'CONFEOF' >> config.status
  rm -f conftest.s1 conftest.sh
  mv conftest.s2 conftest.sh
done
rm -f conftest.sh

# Now back to your regularly scheduled config.status.
cat >> config.status <<\EOF
# This sed command replaces #undef's with comments.  This is necessary, for
# example, in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it in
# Defaults.tmpl.
cat >> conftest.sed <<\CONFEOF
s,^[     ]*#[     ]*undef[     ][     ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
CONFEOF
rm -f conftest.h
# Break up the sed commands because old seds have small limits.
ac_max_sed_lines=20

CONFIG_HEADERS=${CONFIG_HEADERS-"Defaults.tmpl"}
for ac_file in .. ${CONFIG_HEADERS}; do if test "x$ac_file" != x..; then
  echo creating $ac_file

  cp $ac_given_srcdir/$ac_file.in conftest.h1
  cp conftest.sed conftest.stm
  while :
  do
    ac_lines=`grep -c . conftest.stm`
    if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
    rm -f conftest.s1 conftest.s2 conftest.h2
    sed ${ac_max_sed_lines}q conftest.stm > conftest.s1 # Like head -20.
    sed 1,${ac_max_sed_lines}d conftest.stm > conftest.s2 # Like tail +21.
    sed -f conftest.s1 < conftest.h1 > conftest.h2
    rm -f conftest.s1 conftest.h1 conftest.stm
    mv conftest.h2 conftest.h1
    mv conftest.s2 conftest.stm
  done
  rm -f conftest.stm conftest.h
  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
  cat conftest.h1 >> conftest.h
  rm -f conftest.h1
  if cmp -s $ac_file conftest.h 2>/dev/null; then
    # The file exists and we would not be changing it.
    echo "$ac_file is unchanged"
    rm -f conftest.h
  else
    rm -f $ac_file
    mv conftest.h $ac_file
  fi
fi; done
rm -f conftest.sed



exit 0
EOF
chmod +x config.status
test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} config.status


echo
echo finished setup
echo "

Compile with 'make'.

Install with 'make install' and 'make install.man'. If you want to
link the wais libraries into other systems (Mosaic, gopher) then type
'make install.lib' before cleaning with 'make clean'. 'make veryclean'
will in addition remove the tests databases in FIELD-EXAMPLE and the
files generated by flex, bison, latex, dvips.

If you have imake you can alternatively enter

'xmkmf -a'
'make'
'make install'
'make install.man'
'make install.lib'

In the x subdirectory the latter is preferred.

Note, that the Makefiles created by this script do not contain any
dependencies.  If you change some setting, recomplile the whole
distribution or use imake/makedepend to generate the dependencies.

To recreate the autoconf Makefiles enter

'config.status'

Good luck!
";